const express = require('express');
const router = express.Router();

const OrderPrisma = require('../models/OrderPrisma');
const UserPrisma = require('../models/UserPrisma');
const ResponseHelper = require('../utils/response');
const WechatPayService = require('../utils/WechatPayService');

/**
 * 接口 10: 微信支付回调
 * POST /api/v1/payments/wechat/notify
 *
 * 逻辑: 这是给微信服务器调用的接口。接收并验证微信的异步通知。
 * 数据库: 若支付成功，根据订单号更新 orders 表状态为 paid。然后，根据订单中的 user_id 和 package_id，为用户的 publishing_credits 增加相应的条数。
 */
router.post('/wechat/notify', async (req, res) => {
  try {
    // 获取原始请求体（用于签名验证）
    const rawBody = JSON.stringify(req.body);

    // 初始化微信支付服务
    const wechatPayService = new WechatPayService();

    // 验证回调签名（真实支付模式下）
    if (!process.env.PAYMENT_MOCK_MODE || process.env.PAYMENT_MOCK_MODE !== 'true') {
      const isValidSignature = wechatPayService.verifyNotifySignature(req.headers, rawBody);
      if (!isValidSignature) {
        console.error('微信支付回调签名验证失败');
        return res.status(400).send('FAIL');
      }
    }

    // 解析回调数据
    let callbackData;
    if (process.env.PAYMENT_MOCK_MODE === 'true') {
      // 模拟模式：直接使用请求体数据
      callbackData = req.body;
    } else {
      // 真实模式：解密回调数据
      try {
        callbackData = wechatPayService.decryptNotifyData(req.body);
      } catch (decryptError) {
        console.error('解密微信支付回调数据失败:', decryptError);
        return res.status(400).send('FAIL');
      }
    }

    const {
      out_trade_no, // 订单号
      transaction_id, // 微信支付交易号
      trade_state = 'SUCCESS' // 支付状态
    } = callbackData;

    console.log('收到微信支付回调:', {
      out_trade_no,
      transaction_id,
      trade_state,
      mockMode: process.env.PAYMENT_MOCK_MODE === 'true'
    });

    // 验证必要参数
    if (!out_trade_no) {
      console.error('回调数据缺少订单号');
      return res.status(400).send('FAIL');
    }

    // 查找订单
    const order = await OrderPrisma.findByOrderNumber(out_trade_no, {
      include: { user: true, packages: true }
    });

    if (!order) {
      console.error('订单不存在:', out_trade_no);
      return res.status(400).send('FAIL');
    }

    // 检查订单状态
    if (order.status === 'paid') {
      console.log('订单已处理:', out_trade_no);
      return res.send('SUCCESS');
    }

    // 支付成功处理
    if (trade_state === 'SUCCESS') {
      // 更新订单状态为已支付
      const updatedOrder = await OrderPrisma.markAsPaid(out_trade_no, {
        transaction_id: transaction_id || `txn_${Date.now()}`,
        payment_method: 'wechat'
      });

      if (updatedOrder && updatedOrder.packages) {
        // 获取用户信息
        const user = await UserPrisma.findById(updatedOrder.user_id);

        if (user) {
          // 根据套餐类型增加不同的额度
          if (updatedOrder.packages.package_type === 'chat_message') {
            // 聊天消息套餐，增加聊天消息额度
            await UserPrisma.addChatCredits(
              updatedOrder.user_id,
              updatedOrder.packages.credits_amount
            );
            console.log(`支付成功处理完成: 订单${out_trade_no}, 用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条聊天消息次数`);
          } else if (updatedOrder.packages.package_type === 'contact_view') {
            // 查看手机号套餐，增加查看次数
            await UserPrisma.addContactViewCredits(
              updatedOrder.user_id,
              updatedOrder.packages.credits_amount
            );
            console.log(`支付成功处理完成: 订单${out_trade_no}, 用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}次查看手机号次数`);
          } else if (updatedOrder.packages.package_type === 'local_service') {
            // 本地服务套餐，增加本地服务额度
            await UserPrisma.addLocalServiceCredits(
              updatedOrder.user_id,
              updatedOrder.packages.credits_amount
            );
            console.log(`支付成功处理完成: 订单${out_trade_no}, 用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条本地服务发布次数`);
          } else {
            // 其他套餐，增加发布额度
            await UserPrisma.addCredits(
              updatedOrder.user_id,
              updatedOrder.packages.credits_amount
            );
            console.log(`支付成功处理完成: 订单${out_trade_no}, 用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条发布次数`);
          }

          // 如果用户状态为 inactive，自动激活用户
          if (user.status === 'inactive') {
            await UserPrisma.activate(updatedOrder.user_id);
            console.log(`用户${updatedOrder.user_id}已自动激活`);
          }
        }
      }

      return res.send('SUCCESS');
    } else {
      // 支付失败，更新订单状态
      await OrderPrisma.update(order.id, {
        status: 'failed',
        transaction_id: transaction_id || null
      });

      console.log('支付失败:', out_trade_no, trade_state);
      return res.send('SUCCESS');
    }

  } catch (error) {
    console.error('微信支付回调处理错误:', error);
    return res.status(500).send('FAIL');
  }
});

/**
 * 模拟支付成功接口（开发测试用）
 * POST /api/v1/payments/mock/success
 */
router.post('/mock/success', async (req, res) => {
  try {
    const { order_number } = req.body;

    if (!order_number) {
      return ResponseHelper.validationError(res, ['order_number 是必填参数']);
    }

    // 查找订单
    const order = await OrderPrisma.findByOrderNumber(order_number, {
      include: { user: true, package: true }
    });

    if (!order) {
      return ResponseHelper.notFound(res, '订单不存在');
    }

    if (order.status === 'paid') {
      return ResponseHelper.error(res, '订单已支付', 400);
    }

    // 模拟支付成功
    const updatedOrder = await OrderPrisma.markAsPaid(order_number, {
      transaction_id: `mock_txn_${Date.now()}`,
      payment_method: 'wechat'
    });

    if (updatedOrder && updatedOrder.packages) {
      // 获取用户信息
      const user = await UserPrisma.findById(updatedOrder.user_id);

      if (user) {
        // 根据套餐类型增加不同的额度
        if (updatedOrder.packages.package_type === 'chat_message') {
          // 聊天消息套餐，增加聊天消息额度
          await UserPrisma.addChatCredits(
            updatedOrder.user_id,
            updatedOrder.packages.credits_amount
          );
          console.log(`模拟支付：用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条聊天消息次数`);
        } else if (updatedOrder.packages.package_type === 'contact_view') {
          // 查看手机号套餐，增加查看次数
          await UserPrisma.addContactViewCredits(
            updatedOrder.user_id,
            updatedOrder.packages.credits_amount
          );
          console.log(`模拟支付：用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}次查看手机号次数`);
        } else if (updatedOrder.packages.package_type === 'local_service') {
          // 本地服务套餐，增加本地服务额度
          await UserPrisma.addLocalServiceCredits(
            updatedOrder.user_id,
            updatedOrder.packages.credits_amount
          );
          console.log(`模拟支付：用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条本地服务发布次数`);
        } else {
          // 其他套餐，增加发布额度
          await UserPrisma.addCredits(
            updatedOrder.user_id,
            updatedOrder.packages.credits_amount
          );
          console.log(`模拟支付：用户${updatedOrder.user_id}增加${updatedOrder.packages.credits_amount}条发布次数`);
        }

        // 如果用户状态为 inactive，自动激活用户
        if (user.status === 'inactive') {
          await UserPrisma.activate(updatedOrder.user_id);
          console.log(`模拟支付：用户${updatedOrder.user_id}已自动激活`);
        }
      }
    }

    ResponseHelper.success(res, {
      order: updatedOrder.toJSON()
    }, '模拟支付成功');

  } catch (error) {
    console.error('模拟支付错误:', error);
    ResponseHelper.serverError(res, '模拟支付失败', error);
  }
});

/**
 * 查询订单支付状态
 * GET /api/v1/payments/status/:orderNumber
 */
router.get('/status/:orderNumber', async (req, res) => {
  try {
    const { orderNumber } = req.params;

    if (!orderNumber) {
      return ResponseHelper.validationError(res, ['订单号不能为空']);
    }

    // 查找订单
    const order = await OrderPrisma.findByOrderNumber(orderNumber, {
      include: { user: true, package: true }
    });

    if (!order) {
      return ResponseHelper.notFound(res, '订单不存在');
    }

    // 如果订单已支付，直接返回状态
    if (order.status === 'paid') {
      return ResponseHelper.success(res, {
        order: order.toJSON(),
        payment_status: 'paid'
      }, '订单已支付');
    }

    // 如果订单状态为pending，查询微信支付状态
    if (order.status === 'pending') {
      const wechatPayService = new WechatPayService();
      const queryResult = await wechatPayService.queryOrder(orderNumber);

      if (queryResult.success) {
        const { trade_state, transaction_id } = queryResult.data;

        // 如果微信支付显示已支付，但本地订单状态未更新，则更新本地状态
        if (trade_state === 'SUCCESS') {
          const updatedOrder = await OrderPrisma.markAsPaid(orderNumber, {
            transaction_id: transaction_id,
            payment_method: 'wechat'
          });

          if (updatedOrder && updatedOrder.packages) {
            // 获取用户信息并增加额度
            const user = await UserPrisma.findById(updatedOrder.user_id);
            if (user) {
              // 根据套餐类型增加不同的额度
              if (updatedOrder.packages.package_type === 'chat_message') {
                await UserPrisma.addChatCredits(
                  updatedOrder.user_id,
                  updatedOrder.packages.credits_amount
                );
              } else if (updatedOrder.packages.package_type === 'contact_view') {
                await UserPrisma.addContactViewCredits(
                  updatedOrder.user_id,
                  updatedOrder.packages.credits_amount
                );
              } else if (updatedOrder.packages.package_type === 'local_service') {
                await UserPrisma.addLocalServiceCredits(
                  updatedOrder.user_id,
                  updatedOrder.packages.credits_amount
                );
              } else {
                await UserPrisma.addCredits(
                  updatedOrder.user_id,
                  updatedOrder.packages.credits_amount
                );
              }

              // 如果用户状态为 inactive，自动激活用户
              if (user.status === 'inactive') {
                await UserPrisma.activate(updatedOrder.user_id);
              }
            }
          }

          return ResponseHelper.success(res, {
            order: updatedOrder.toJSON(),
            payment_status: 'paid'
          }, '支付成功');
        } else if (trade_state === 'CLOSED' || trade_state === 'PAYERROR') {
          // 支付失败或关闭
          await OrderPrisma.update(order.id, {
            status: 'failed',
            transaction_id: transaction_id || null
          });

          return ResponseHelper.success(res, {
            order: order.toJSON(),
            payment_status: 'failed'
          }, '支付失败');
        } else {
          // 支付中
          return ResponseHelper.success(res, {
            order: order.toJSON(),
            payment_status: 'pending'
          }, '支付中');
        }
      } else {
        // 查询失败，返回当前状态
        return ResponseHelper.success(res, {
          order: order.toJSON(),
          payment_status: 'pending'
        }, '支付状态查询中');
      }
    }

    // 其他状态直接返回
    return ResponseHelper.success(res, {
      order: order.toJSON(),
      payment_status: order.status
    }, '订单状态查询成功');

  } catch (error) {
    console.error('查询支付状态错误:', error);
    ResponseHelper.serverError(res, '查询支付状态失败', error);
  }
});

module.exports = router;
